Uwierzytelnianie w Python Django: Opanowanie niestandardowych modeli użytkowników dla globalnych aplikacji

Wbudowany system uwierzytelniania Django to potężny punkt wyjścia dla wielu aplikacji internetowych. Jednak w miarę skalowania i komplikowania się aplikacji, szczególnie w przypadku globalnej publiczności, domyślny model użytkownika może okazać się niewystarczający. Właśnie tutaj wkraczają niestandardowe modele użytkowników, oferując większą elastyczność i kontrolę nad danymi użytkowników i procesami uwierzytelniania. Ten kompleksowy przewodnik przeprowadzi Cię przez proces tworzenia i implementacji niestandardowych modeli użytkowników w Django, zapewniając, że Twoja aplikacja będzie dobrze przygotowana do obsługi zróżnicowanych wymagań użytkowników i kwestii bezpieczeństwa.

Dlaczego warto używać niestandardowego modelu użytkownika?

Domyślny model użytkownika Django został zaprojektowany z typowymi atrybutami, takimi jak nazwa użytkownika, hasło, e-mail, imię i nazwisko. Chociaż nadaje się do prostych aplikacji, często okazuje się niewystarczający, gdy potrzebujesz:

• Przechowywać dodatkowe informacje o użytkowniku: Rozważ globalną platformę e-commerce, która musi przechowywać preferencje użytkowników, adresy w różnych formatach, preferowane waluty lub ustawienia języka. Wykracza to poza zakres domyślnego modelu.
• Zmienić pole uwierzytelniania: Być może chcesz uwierzytelniać użytkowników za pomocą ich adresu e-mail zamiast nazwy użytkownika, lub wdrożyć uwierzytelnianie wieloskładnikowe wymagające dodatkowych pól.
• Integrować z istniejącymi bazami danych: Jeśli integrujesz aplikację Django z istniejącą bazą danych, która ma inny schemat użytkowników, niestandardowy model użytkownika pozwala na mapowanie Twojego modelu do istniejącej struktury danych.
• Zwiększyć bezpieczeństwo: Niestandardowe modele umożliwiają większą kontrolę nad haszowaniem haseł, mechanizmami resetowania haseł i innymi aspektami związanymi z bezpieczeństwem.
• Wdrożyć różne role użytkowników: Bezpośrednie przechowywanie danych kontroli dostępu opartej na rolach (RBAC) w modelu (lub odwoływanie się do nich) oferuje bardziej elastyczną i jawną kontrolę niż ogólne grupy i uprawnienia.

Użycie niestandardowego modelu użytkownika zapewnia czysty i łatwy w utrzymaniu sposób rozszerzania profilu użytkownika bez bezpośredniej modyfikacji podstawowego systemu uwierzytelniania Django. Jest to najlepsza praktyka dla każdego projektu, który przewiduje przyszły rozwój lub wymaga specjalistycznych danych użytkownika.

Kiedy należy zaimplementować niestandardowy model użytkownika?

Najlepszy czas na zaimplementowanie niestandardowego modelu użytkownika to początek Twojego projektu. Zmiana modelu użytkownika w środowisku produkcyjnym może być złożona i potencjalnie szkodliwa dla danych. Jeśli Twój projekt jest już w toku, dokładnie rozważ konsekwencje i stwórz solidny plan migracji przed wprowadzeniem jakichkolwiek zmian.

Oto ogólne wytyczne:

• Zacznij od niestandardowego modelu użytkownika: Jeśli przewidujesz potrzebę rozszerzonych informacji o użytkowniku lub niestandardowej logiki uwierzytelniania.
• Starannie rozważ migrację: Jeśli masz już działający projekt Django z użytkownikami i zdecydujesz się przełączyć na niestandardowy model. Wykonaj kopię zapasową bazy danych i dokładnie zapoznaj się z procesem migracji.

Tworzenie niestandardowego modelu użytkownika

Istnieją dwa główne podejścia do tworzenia niestandardowego modelu użytkownika w Django:

1. AbstractBaseUser: To podejście daje Ci pełną kontrolę nad modelem użytkownika. Definiujesz wszystkie pola, w tym nazwę użytkownika, hasło, e-mail i wszelkie niestandardowe pola, których potrzebujesz.
2. AbstractUser: To podejście dziedziczy z domyślnego modelu użytkownika Django i pozwala dodawać lub nadpisywać istniejące pola. Jest to prostsze, jeśli potrzebujesz dodać tylko kilka dodatkowych pól.

1. Użycie AbstractBaseUser (pełna kontrola)

To najbardziej elastyczna opcja, pozwalająca na zdefiniowanie całego modelu użytkownika od podstaw. Zapewnia największą kontrolę nad strukturą danych użytkownika i procesem uwierzytelniania. Oto jak:

Krok 1: Utwórz niestandardowy model użytkownika

W Twojej aplikacji Django (np. 'accounts') utwórz plik `models.py` i zdefiniuj swój niestandardowy model użytkownika dziedziczący z `AbstractBaseUser` i `PermissionsMixin`:

            from django.db import models
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, BaseUserManager

class CustomUserManager(BaseUserManager):
    def create_user(self, email, password=None, **extra_fields):
        if not email:
            raise ValueError('The Email field must be set')
        email = self.normalize_email(email)
        user = self.model(email=email, **extra_fields)
        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, email, password, **extra_fields):
        extra_fields.setdefault('is_staff', True)
        extra_fields.setdefault('is_superuser', True)
        extra_fields.setdefault('is_active', True)

        if extra_fields.get('is_staff') is not True:
            raise ValueError('Superuser must have is_staff=True.')
        if extra_fields.get('is_superuser') is not True:
            raise ValueError('Superuser must have is_superuser=True.')

        return self.create_user(email, password, **extra_fields)

class CustomUser(AbstractBaseUser, PermissionsMixin):
    email = models.EmailField(unique=True, verbose_name='email address')
    first_name = models.CharField(max_length=150, blank=True)
    last_name = models.CharField(max_length=150, blank=True)
    is_staff = models.BooleanField(default=False)
    is_active = models.BooleanField(default=True)
    date_joined = models.DateTimeField(auto_now_add=True)

    # Custom fields (Example: preferred language, timezone, etc.)
    preferred_language = models.CharField(max_length=10, default='en', choices=[('en', 'English'), ('fr', 'French'), ('es', 'Spanish')])
    timezone = models.CharField(max_length=50, default='UTC')

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = [] # Required when creating a superuser

    objects = CustomUserManager()

    def __str__(self):
        return self.email

            

              
                Copy
              
            
          

Wyjaśnienie:

• CustomUserManager: Ta klasa jest wymagana do zarządzania Twoim niestandardowym modelem użytkownika. Obsługuje tworzenie użytkowników i superużytkowników. `normalize_email` jest ważny dla zapewnienia spójności adresu e-mail w różnych lokalizacjach i metodach wprowadzania.
• CustomUser: To jest Twój niestandardowy model użytkownika.
• `email = models.EmailField(unique=True, verbose_name='email address')`: Definiuje pole e-mail jako unikalny identyfikator użytkownika. Użycie `unique=True` zapewnia, że każdy użytkownik ma unikalny adres e-mail. Pełna nazwa poprawia interfejs administratora.
• `first_name`, `last_name`: Standardowe pola do przechowywania imienia i nazwiska użytkownika. `blank=True` pozwala na pozostawienie tych pól pustych.
• `is_staff`, `is_active`: Standardowe pola do kontrolowania dostępu użytkownika do panelu administracyjnego i aktywacji konta.
• `date_joined`: Rejestruje datę utworzenia konta użytkownika.
• `preferred_language`, `timezone`: Przykładowe niestandardowe pola do przechowywania preferencji użytkownika. Argument `choices` ogranicza możliwe opcje języków. Jest to kluczowe dla globalnej aplikacji. Strefa czasowa jest również ważna dla lokalizacji.
• `USERNAME_FIELD = 'email'`: Określa, że pole e-mail będzie używane jako nazwa użytkownika do uwierzytelniania.
• `REQUIRED_FIELDS = []`: Określa pola, które są wymagane podczas tworzenia superużytkownika za pomocą polecenia `createsuperuser`. W tym przypadku, oprócz adresu e-mail i hasła, nie są wymagane żadne dodatkowe pola.
• `objects = CustomUserManager()`: Przypisuje niestandardowego menedżera użytkowników do modelu.
• `__str__(self)`: Definiuje, jak obiekt użytkownika jest reprezentowany jako ciąg znaków (np. w panelu administratora).

Krok 2: Zaktualizuj `settings.py`

Poinformuj Django o użyciu Twojego niestandardowego modelu użytkownika, dodając następującą linię do pliku `settings.py`:

            AUTH_USER_MODEL = 'accounts.CustomUser'
            

              
                Copy
              
            
          

Zastąp `accounts` nazwą Twojej aplikacji, w której zdefiniowałeś model `CustomUser`.

Krok 3: Utwórz i zastosuj migracje

Uruchom następujące polecenia, aby utworzyć i zastosować migracje:

            python manage.py makemigrations
python manage.py migrate
            

              
                Copy
              
            
          

Spowoduje to utworzenie nowej tabeli w bazie danych dla Twojego niestandardowego modelu użytkownika.

Krok 4: Użycie niestandardowego modelu użytkownika

Teraz możesz używać swojego niestandardowego modelu użytkownika w widokach, szablonach i innych częściach aplikacji. Na przykład, aby utworzyć nowego użytkownika:

            from accounts.models import CustomUser

user = CustomUser.objects.create_user(email='user@example.com', password='password123', first_name='John', last_name='Doe')
            

              
                Copy
              
            
          

2. Użycie AbstractUser (dodawanie do domyślnego modelu)

To podejście jest prostsze, jeśli potrzebujesz dodać tylko kilka dodatkowych pól do domyślnego modelu użytkownika Django. Dziedziczy ono wszystkie istniejące pola i metody z `AbstractUser`. Może to być łatwiejsze dla prostszych dostosowań.

Krok 1: Utwórz niestandardowy model użytkownika

W pliku `models.py` Twojej aplikacji Django zdefiniuj swój niestandardowy model użytkownika dziedziczący z `AbstractUser`:

            from django.contrib.auth.models import AbstractUser
from django.db import models

class CustomUser(AbstractUser):
    # Add extra fields here
    phone_number = models.CharField(max_length=20, blank=True, verbose_name='Phone Number')
    profile_picture = models.ImageField(upload_to='profile_pictures/', blank=True)
    # Custom fields (Example: preferred currency, address format, etc.)
    preferred_currency = models.CharField(max_length=3, default='USD', choices=[('USD', 'US Dollar'), ('EUR', 'Euro'), ('JPY', 'Japanese Yen')])
    address_format = models.CharField(max_length=50, blank=True, help_text='e.g., "Name, Street, City, Zip, Country"')

    def __str__(self):
        return self.username

            

              
                Copy
              
            
          

Wyjaśnienie:

• CustomUser: To jest Twój niestandardowy model użytkownika, dziedziczący z `AbstractUser`.
• `phone_number`, `profile_picture`: Przykładowe pola do dodania do modelu użytkownika. `upload_to` określa, gdzie będą przechowywane zdjęcia profilowe.
• `preferred_currency`, `address_format`: Przykładowe niestandardowe pola istotne dla globalnych aplikacji. Różne kraje mają drastycznie różne formaty adresów.
• `__str__(self)`: Definiuje, jak obiekt użytkownika jest reprezentowany jako ciąg znaków (np. w panelu administratora). Tutaj używa nazwy użytkownika.

Krok 2: Zaktualizuj `settings.py`

Tak jak poprzednio, poinformuj Django o użyciu Twojego niestandardowego modelu użytkownika, dodając następującą linię do pliku `settings.py`:

            AUTH_USER_MODEL = 'accounts.CustomUser'
            

              
                Copy
              
            
          

Krok 3: Utwórz i zastosuj migracje

Uruchom następujące polecenia, aby utworzyć i zastosować migracje:

            python manage.py makemigrations
python manage.py migrate
            

              
                Copy
              
            
          

Krok 4: Użycie niestandardowego modelu użytkownika

Teraz możesz uzyskiwać dostęp do dodanych pól podczas pracy z obiektami użytkowników:

            from accounts.models import CustomUser

user = CustomUser.objects.create_user(username='johndoe', password='password123', email='john.doe@example.com')
user.phone_number = '+15551234567'
user.preferred_currency = 'EUR'
user.save()
            

              
                Copy
              
            
          

Najlepsze praktyki dla niestandardowych modeli użytkowników w globalnych aplikacjach

Podczas implementowania niestandardowych modeli użytkowników dla aplikacji skierowanych do globalnej publiczności, rozważ następujące najlepsze praktyki:

1. Internacjonalizacja i lokalizacja (i18n & l10n)

Przechowuj dane specyficzne dla lokalizacji: Zaprojektuj swój model tak, aby uwzględniał różne normy kulturowe i formaty danych. Przechowuj daty, godziny, liczby i adresy w sposób uwzględniający lokalizację.

Przykład:

            from django.utils import timezone

class CustomUser(AbstractUser):
    #...
    date_of_birth = models.DateField(blank=True, null=True)

    def get_localized_date_of_birth(self, language_code):
        if self.date_of_birth:
            return timezone.localtime(timezone.make_aware(datetime.datetime.combine(self.date_of_birth, datetime.time.min))).strftime('%x')  # Format according to the locale
        return None
            

              
                Copy
              
            
          

2. Obsługa stref czasowych

Zawsze poprawnie przechowuj i obsługuj strefy czasowe. Przechowuj informacje o strefie czasowej w modelu użytkownika i używaj ich do wyświetlania dat i godzin w lokalnej strefie czasowej użytkownika.

Przykład:

            from django.utils import timezone

class CustomUser(AbstractUser):
    #...
    timezone = models.CharField(max_length=50, default='UTC')

    def get_localized_time(self, datetime_obj):
        user_timezone = pytz.timezone(self.timezone)
        return timezone.localtime(datetime_obj, user_timezone)
            

              
                Copy
              
            
          

3. Formatowanie adresów

Formaty adresów znacznie różnią się w zależności od kraju. Zaimplementuj elastyczny system adresowy, który pozwala użytkownikom wprowadzać adres w prawidłowym formacie dla ich lokalizacji. Rozważ użycie biblioteki lub usługi zewnętrznej do walidacji i formatowania adresów.

Przykład:

            class CustomUser(AbstractUser):
    #...
    country = models.CharField(max_length=50, blank=True)
    address_line_1 = models.CharField(max_length=255, blank=True)
    address_line_2 = models.CharField(max_length=255, blank=True)
    city = models.CharField(max_length=100, blank=True)
    postal_code = models.CharField(max_length=20, blank=True)

    def get_formatted_address(self):
        # Implement logic to format address based on country
        if self.country == 'US':
            return f'{self.address_line_1}\n{self.address_line_2}\n{self.city}, {self.postal_code}, {self.country}'
        elif self.country == 'GB':
            return f'{self.address_line_1}\n{self.address_line_2}\n{self.city}\n{self.postal_code}\n{self.country}'
        else:
            return 'Address format not supported'

            

              
                Copy
              
            
          

4. Obsługa walut

Jeśli Twoja aplikacja obejmuje transakcje finansowe, przechowuj preferowaną walutę użytkownika i używaj jej do wyświetlania cen i kwot. Użyj biblioteki takiej jak `babel`, aby formatować wartości walut zgodnie z lokalizacją użytkownika.

Przykład:

            from babel.numbers import format_currency

class CustomUser(AbstractUser):
    #...
    preferred_currency = models.CharField(max_length=3, default='USD')

    def get_formatted_price(self, amount):
        return format_currency(amount, self.preferred_currency, locale='en_US')  # Adjust locale as needed
            

              
                Copy
              
            
          

5. Walidacja danych

Zaimplementuj solidną walidację danych, aby zapewnić, że dane wprowadzane przez użytkownika są prawidłowe i spójne. Użyj wbudowanych walidatorów Django lub stwórz niestandardowe walidatory, aby wymusić integralność danych.

Przykład:

            from django.core.validators import RegexValidator

class CustomUser(AbstractUser):
    #...
    phone_number = models.CharField(
        max_length=20,
        blank=True,
        validators=[
            RegexValidator(
                regex=r'^\\+?\\d{9,15}$',
                message="Phone number must be entered in the format: '+999999999'. Up to 15 digits allowed."
            ),
        ]
    )
            

              
                Copy
              
            
          

6. Kwestie bezpieczeństwa

Haszowanie haseł: System uwierzytelniania Django domyślnie używa silnych algorytmów haszowania haseł. Upewnij się, że używasz najnowszej wersji Django, aby korzystać z najnowszych aktualizacji bezpieczeństwa.

Uwierzytelnianie dwuskładnikowe (2FA): Zaimplementuj 2FA, aby dodać dodatkową warstwę bezpieczeństwa do kont użytkowników. Dostępne są różne pakiety Django do tego celu, takie jak `django-otp`. Jest to szczególnie ważne podczas obsługi wrażliwych danych użytkowników lub transakcji finansowych.

Ochrona danych: Postępuj zgodnie z najlepszymi praktykami w zakresie ochrony i prywatności danych, zwłaszcza w przypadku wrażliwych informacji o użytkownikach. Przestrzegaj odpowiednich przepisów o ochronie danych, takich jak RODO i CCPA. Rozważ techniki szyfrowania, anonimizacji i tokenizacji danych.

7. Testowanie

Napisz kompleksowe testy jednostkowe i integracyjne, aby upewnić się, że Twój niestandardowy model użytkownika działa zgodnie z oczekiwaniami, a system uwierzytelniania jest bezpieczny. Przetestuj różne scenariusze, w tym prawidłowe i nieprawidłowe dane wejściowe użytkownika, przepływy resetowania hasła i sprawdzenia uprawnień.

8. Dokumentacja

Dokładnie udokumentuj swój niestandardowy model użytkownika i system uwierzytelniania. Ułatwi to innym programistom zrozumienie i utrzymanie Twojego kodu. Dołącz informacje o przeznaczeniu każdego pola, przepływie uwierzytelniania i wszelkich kwestiach bezpieczeństwa.

Zaawansowane techniki i rozważania

1. Niestandardowe menedżery użytkowników

Jak pokazano w przykładzie `AbstractBaseUser`, niestandardowe menedżery użytkowników są niezbędne do tworzenia i zarządzania użytkownikami. Pozwalają one definiować niestandardową logikę tworzenia użytkowników, taką jak ustawianie wartości domyślnych dla określonych pól lub przeprowadzanie dodatkowej walidacji.

2. Modele proxy

Modele proxy pozwalają dodawać metody do modelu użytkownika bez zmiany schematu bazy danych. Może to być przydatne do dodawania niestandardowej logiki lub obliczeń specyficznych dla Twojej aplikacji.

3. Rozszerzanie modelu użytkownika za pomocą modelu profilu

Zamiast dodawać wiele pól bezpośrednio do modelu użytkownika, możesz utworzyć oddzielny model profilu, który ma relację jeden-do-jednego z modelem użytkownika. Może to pomóc w utrzymaniu porządku i czystości Twojego modelu użytkownika.

            from django.db import models
from django.conf import settings

class UserProfile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='profile')
    # Additional fields
    bio = models.TextField(blank=True)
    location = models.CharField(max_length=100, blank=True)

            

              
                Copy
              
            
          

Pamiętaj, aby utworzyć sygnał, który automatycznie utworzy UserProfile po utworzeniu użytkownika:

            from django.db.models.signals import post_save
from django.dispatch import receiver
from django.conf import settings
from .models import UserProfile

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        UserProfile.objects.create(user=instance)

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def save_user_profile(sender, instance, **kwargs):
    instance.profile.save()

            

              
                Copy
              
            
          

4. Jednokrotne logowanie (SSO)

Dla większych organizacji lub aplikacji wymagających integracji z innymi usługami, rozważ zaimplementowanie Jednokrotnego Logowania (SSO) przy użyciu protokołów takich jak OAuth 2.0 lub SAML. Django oferuje kilka pakietów, które upraszczają integrację SSO, takich jak `django-allauth`.

5. Logowanie audytu

Zaimplementuj logowanie audytu, aby śledzić aktywność użytkowników i zmiany w danych użytkowników. Może to być przydatne do monitorowania bezpieczeństwa, zgodności i debugowania. Pakiety takie jak `django-auditlog` mogą pomóc w automatyzacji tego procesu.

Podsumowanie

Tworzenie i implementowanie niestandardowych modeli użytkowników w Django zapewnia elastyczność i kontrolę, których potrzebujesz do budowania solidnych i skalowalnych systemów uwierzytelniania, zwłaszcza dla globalnych aplikacji. Postępując zgodnie z najlepszymi praktykami opisanymi w tym przewodniku, możesz zapewnić, że Twoja aplikacja będzie dobrze przygotowana do obsługi zróżnicowanych wymagań użytkowników, utrzymania integralności danych oraz zapewnienia bezpiecznego i przyjaznego dla użytkownika doświadczenia dla użytkowników na całym świecie. Pamiętaj, aby starannie zaplanować implementację, wziąć pod uwagę potrzeby użytkowników i priorytetowo traktować bezpieczeństwo na każdym etapie procesu. Wybór między `AbstractBaseUser` a `AbstractUser` zależy od wymaganego poziomu dostosowania. W przypadku znaczących zmian, `AbstractBaseUser` oferuje większą kontrolę. Dla prostych rozszerzeń, `AbstractUser` zapewnia płynniejsze przejście. Dokładne testowanie jest kluczowe, aby upewnić się, że niestandardowy model użytkownika bezproblemowo integruje się z resztą Twojej aplikacji Django i spełnia wszystkie wymagania bezpieczeństwa. Przyjmij najlepsze praktyki w zakresie internacjonalizacji, lokalizacji i obsługi stref czasowych, aby zapewnić prawdziwie globalne doświadczenie. Przyczyni się to znacząco do sukcesu i przyjęcia Twojej aplikacji na zróżnicowanych rynkach na całym świecie.